import sys
import re
import os
import base64
import mimetypes
import smtplib

import errno
#import winsound
import platform

import codecs

from EMLsqlite import Database



#BD---------------------------------------------------------------------------------
def rellenarAdjuntoBD(filepath,fileparent):
	"""guardar en la bd en files el adjunto actual i su padre"""

	global databasename

	print "[rellenarAdjuntoBD ]"
	lastidparent = -1
	db = Database(databasename)


	try:
		lastidparent = db.get_id_file(fileparent)
		if (lastidparent == -1):
			lastidparent = db.add_file(fileparent)
		print "[rellenarAdjuntoBD ] lastidparent = %d " % lastidparent
		
	except Exception, e:
		db.close()
		print "[rellenarAdjuntoBD ] error:%s con  %s y fileparent:%s" % (e,filepath,fileparent)


	try:
		lastidfile = db.get_id_file(filepath)
		if (lastidfile == -1):
			print "[rellenarAdjuntoBD ] inserting with lastidparent = %d " % lastidparent
			lastidfile = db.add_file(filepath,lastidparent)
			print "[rellenarAdjuntoBD ] inserted with lastidparent = %d  lastidfile = %d " % (lastidparent,lastidfile)
		else:
			raise
		print "[rellenarAdjuntoBD ] insertado:n  %s y fileparent:%s" %   (filepath,fileparent)
		db.close()
		
	except Exception, e:
		db.close()
		print "[rellenarAdjuntoBD ] error insertando %s con  %s y fileparent:%s" %   (e,filepath,fileparent)
		




	
def rellenarCorreoBD(filepath):
	"""guardar en la bd en files el adjunto actual i su padre"""
	global databasename

	
	db = Database(databasename)
	
	try:
		lastidfile = db.get_id_file(filepath)
		if (lastidfile == -1):
			lastidfile = db.add_file(filepath)
		else:
			raise
		print "[rellenarCorreoBD ] insertado %s " % filepath
		db.close()
	except Exception, e:
		db.close()
		print "[rellenarCorreoBD ] error:%s con  %s " %   (e,filepath)
		
	






#-------------------------------------

def to_unicode_or_bust(obj, encoding='iso_8859_1'):
        if isinstance(obj, basestring):
                if not isinstance(obj, unicode):
                        obj = unicode(obj, encoding)
        return obj

class DirWalker(object):

        def walk(self,dir,meth):
                """ walks a directory, and executes a callback on each file """
                dir = os.path.abspath(dir)
                #print "dir absolute path= %s " % dir
                for file in [file for file in os.listdir(dir) if not file in [".",".."]]:
                        
                        try:
                          
                          dir = to_unicode_or_bust(dir)
                          file = to_unicode_or_bust(file)

                          #print "\n\n      file= %s " % file
                          nfile = os.path.join(dir,file)
                          
                          #print "WORKING WITH %s " % nfile
                          if os.path.isfile(nfile):
                            #print "------ IS FILE "
                            meth(nfile)
                          elif os.path.isdir(nfile):
                            #print "------ IS DIR "
                            self.walk(nfile,meth)
                        except:
                          print "exception handling %s" % file


def UnicodeOrIso8859(encodedstr):
  try:
    result = encodedstr.decode("UTF-8")
  except UnicodeDecodeError:
    result = encodedstr.decode("ISO-8859-1")
  return result

def decodificarContent(contenido):
    """ #entrada: string (enbinario)
        #buscar Content-Transfer-Encoding: base64
                #si lo tiene:
                        #CORTAR PEDAZO
                        #DECODIFICAR
                        #VOLVER A PEGAR
                #si no lo tiene : nada
        #salida: string1 (con reemplazo o igual) """
       
    #Content-Transfer-Encoding: base64
    iE = contenido.find(b'Content-Transfer-Encoding: base64')
    if (iE == -1 ):
                return contenido
        
    print " indice Content-Transfer-Encoding: base64 %d " % iE
    substrC = contenido[0:iE]
    substrD = contenido[iE:]
    ib64 = substrD.find(b'base64') + 6
    print " indice se acaba Content-Transfer-Encoding: base64 %d " % ib64
    substrE = substrD[ib64:]


    
    #FIN DEL BLOQUE DESCRIPTIVO
    print "platform : %s " % platform.system()
    if(platform.system() == 'Windows'):
      #windows version
      strdoblesalto = b'\r\n\r\n'
      #si proviene de readPST contiene los caracteres de salto de linea de linux:
      strdoblesalto = b'\n\n'  
    else:
      #linux version
      strdoblesalto = b'\n\n'
    
    lendoblesalto = len(strdoblesalto)
    idoblesalto = substrE.find(strdoblesalto)
    substr1 = substrE[:idoblesalto+lendoblesalto]
    strADecodificar  = substrE[idoblesalto+lendoblesalto:]
    
    print "buscando en : %s " % substrE[:200]
    print "inidice doblesalto %d " % idoblesalto
    #print "doblesalto = %s " % strdoblesalto
    print "lendoblesalto = %s " % lendoblesalto
    print "inicio base64 = %s " % strADecodificar[:10]
    


    #substring inici fins a base64
    substr0 = substrC  # de inici fins abans de content-transfer-encoding: base64
    substr2 = strADecodificar # de final de base4 a final de tot (ja no posar content-transfer-encoding
    

    print "decodificar: %s" % substr2[:20]
    #base64.b64decode(s[, altchars])
    substrFINAL = base64.b64decode(substr2)
    #print "decodificada como : %s" % substrFINAL
            
    #enganxar tots els substrings amb la substring codificadad
    #amb format stringss
    #substrF = "%s%s%s" % (substr0,substrFINAL,substr2)
    substrF = substr0 + b'\x0D\x0A' + substr1 +  substrFINAL + b'\x0D\x0A' 

    return substrF


def decodificarAdjunto(contenido):
    """#entrada: string (enbinario)
        #buscar Content-Disposition: attachment; filename="image001.jpg"
                #guardar nombre de fichero
                #mirar si existe->si existe guardar nomrbe de fichero + _1
        #buscar Content-Transfer-Encoding: base64
                #si lo tiene:
                        #CORTAR PEDAZO
                        #DECODIFICAR
                        #GUARDAR CON NOMBRE DE FICHERO
                #si no lo tiene : nada

        #salida: nada"""

    global directorio_actual
    global fichero_actual
    global fileParentResultado
    global contador



    #Contenido-----------------------------------------------------
    #Content-Transfer-Encoding: base64
    iE = contenido.find(b'Content-Transfer-Encoding: base64')
    if (iE == -1 ):
                return contenido

    #print " indice Content-Transfer-Encoding: base64 %d " % iE
    substrC = contenido[0:iE]
    substrD = contenido[iE:]

    ib64 = substrD.find(b'base64') + 6
    #print " indice se acaba Content-Transfer-Encoding: base64 %d " % ib64
    substrE = substrD[ib64:]
    #print " el resto:  %s " % substrE[:100]

    #substring inici fins a base64
    substr0 = substrC  # de inici fins abans de content-transfer-encoding: base64

    print "platform : %s " % platform.system()
    if(platform.system() == 'Windows'):
      #windows version
      strdoblesalto = b'\r\n\r\n'
      #si proviene de readPST contiene los caracteres de salto de linea de linux:
      strdoblesalto = b'\n\n'  
    else:
      #linux version
      strdoblesalto = b'\n\n'
    
    
    lendoblesalto = len(strdoblesalto)
    idoblesalto = substrE.find(strdoblesalto)
    substr2 = substrE[:idoblesalto+lendoblesalto]
    strADecodificar  = substrE[idoblesalto+lendoblesalto:]
    
    print "buscando en : %s " % substrE[:200]
    print "inidice doblesalto %d " % idoblesalto
    #print "doblesalto = %s " % strdoblesalto
    print "lendoblesalto = %s " % lendoblesalto
    print "inicio base64 = %s " % strADecodificar[:10]
    
    
    #base64.b64decode(s[, altchars])
    substrFINAL = base64.b64decode(strADecodificar)
    #substrFINAL =  substrFINAL
    #print " resultado decodif:  %s " % substrFINAL[:100]
    #obtener directorio base: var global directorio_actual



    
         
    #filename-------------------------------------------------------------
    ifilename = contenido.find(b'filename=')
    if (ifilename == -1 ):
                return contenido
    strfilename = contenido[ifilename + 10:]
    ifilename2 = strfilename.find(b'"')
    strfilename = strfilename[: ifilename2]
    print "strfilename: %s" % strfilename
    #print "\\\\\\\\\\\\\FILENAME encontrado pos %d %d, valor %s " % (ifilename + 10,ifilename + 10 + ifilename2,strfilename)
       


        
    #guardar string decodificada a fichero
    strfilename2 = "adjunto"
    #extraer encoding
    encoded = strfilename
    prefilename = encoded.find('=?')
    presuffilename = encoded.find('?B?')
    suffilename = encoded.find('?=')
    print "before encoded name: %s" % strfilename
    if (prefilename != -1 and presuffilename != -1 and suffilename != -1):
        #filename con encoding tambien
        try:
                encoding = encoded[prefilename+2:presuffilename]
                #prefix = '=?UTF-8?B?'
                #prefix = '=?iso-8859-1?B?'
                prefix = encoded[0:presuffilename + 3]
                suffix = '?='

                #extract the data part of the string
                middle = encoded[len(prefix):len(encoded)-len(suffix)]
                
                print "before decoding b64  name: %s" % middle
                #decode the bytes
                decoded = base64.b64decode(middle)
                
                print "after decoding b64  name: %s" % decoded
                #decode the utf-8
                decoded = unicode(decoded, encoding)
                
                print "after unicoding   decoded: %s   encoding: %s" % (decoded, encoding)


                strfilename = decoded
                
                strfilename2 = strfilename.encode('utf8', 'ignore')
		
		strfilename = strfilename2
        
        except Exception:
                print "ERROR FICHERO %s " % fichero_actual

                        
    print "preparar adjunto decodificado"
    
                        
                        
    #preparar adjunto decodificado--------------------------------------------
    #antesfilename
    #preFilename = contenido[:ifilename + 10]
    #filename
    #filenameDecoded = strfilename
    #despuesfilename
    #postFilename = contenido[(ifilename + ifilename2): (iE + ib64 + idoblesalto+4) ]
    #quitando el content-encoding: base64
    #postFilename = contenido[(ifilename + 10 + ifilename2): (iE) ] + b'\r\n\r\n'
    #base64encoding-decoded = substrFINAL
    #substrFINAL
    #final
    
    print "fichero_actual:"
    print fichero_actual
    print "strfilename:"
    print strfilename.decode("ISO-8859-1")
    
    #copiar a fichero DECODIFICADO------------------------------------------------------------
    #print "escribiendo en disco..."
    #strfilename = fichero_actual + "_".encode("UTF-8") + strfilename
    #strfilename = fichero_actual + str("_") + strfilename
    #strfilename = fichero_actual.decode("ISO-8859-1") + "_" + strfilename.decode("ISO-8859-1")
    #strfilename = fichero_actual.decode("UTF-8") + "_" + strfilename.decode("UTF-8")
  
    strfilename = UnicodeOrIso8859(fichero_actual) + "_" + UnicodeOrIso8859(strfilename)
    
    try:
	    #print "preparar escritura adjunto decodificado strfilename: %s" % strfilename
	    fileresultado = os.path.join(directorio_actual,strfilename)
	    print "preparar escritura adjunto decodificado fileresultado: %s" % fileresultado
	    ffinal = open(fileresultado,'wb')
	    ffinal.write(substrFINAL)
	    
	    #print "escrito!"
    except Exception,e:
	    print "error %s decodificando adjunto de fileresultado: %s" % (e,fileresultado)
    	    
    try:
    	#BD
    	rellenarAdjuntoBD(fileresultado,fileParentResultado)
    except Exception,e:
	print "error %s insertando en la bd de fileresultado: %s" % (e,fileresultado)
    
    

    #devolver adjunto CODIFICADO /YA NO ESTA decodificado------------------------------------------------------
    #print "FINALMENTE: " + preFilename + filenameDecoded + postFilename + substrFINAL[:5] + "..."
    #adjuntoDecodificado = preFilename + filenameDecoded + postFilename + substrFINAL + b'\r\n\r\n'
    #return  adjuntoDecodificado
    return contenido
    
	
#return contenido
#return  b'\x0D\x0A' +  strfilename2 + b'\x0D\x0A' 


def decodificacionBoundarySMTP(contenido,indicadorBoundary):
    """#buscar el primer indicadorBoundary i1
        #buscar siguiente indicador Boundary i2
        #bucle mientras i2 > i1   
                #cortar de i1 a i2
                        #funcion para repetir proceso  (verificar si es multipart o no....)
                        #el resultado devuelto es pegado de nuevo entre i1 e i2
                #i1=i2
                #buscar siguiente indicador Boundary i2
        """
    #buscar el primer indicadorBoundary i1
    i1 = contenido.find(b'--' + indicadorBoundary)
    #print "buscar el priemr indicador Boundary: %d " % i1
    lenbound = len(indicadorBoundary) + 2
    i1 = i1 + lenbound 
    #print "-->indicador boundary: %d y contiene %s" % (i1,contenido[i1 - lenbound:i1+2])
        # empezamos a guardar parte del resultado
    Resultado = contenido[0:i1]
    parteFinal = contenido[i1:]
    i1=0
    #buscar siguiente indicador Boundary i2
    i2 = parteFinal.find(b'--' + indicadorBoundary)
    #print "-->indicador boundary: %d y contiene %s" % (i2,parteFinal[i2:i2+lenbound+2])
    
        #bucle mientras i2 > i1
    while (i2 >= 0 and i2 < len(parteFinal) ):
                #print "while,  i1:%d i2:%d len(parteFinal):%d " % (i1,i2,len(parteFinal))
                #cortar de i1 a i2
                parteBoundary = parteFinal[0:i2]
                parteFinal = parteFinal[i2:]
                #funcion para repetir proceso  (verificar si es multipart o no....)
                resultadoParcial = analysisFicheroEML(parteBoundary)
                #el resultado devuelto es pegado de nuevo entre i1 e i2
                Resultado = Resultado + resultadoParcial + parteFinal[0:lenbound]
                # Actualizar parte a tratar
                parteFinal = parteFinal[lenbound:]
                
                
                #buscar siguiente indicador Boundary i2
                i2 = parteFinal.find(b'--' + indicadorBoundary)
                if (i2 == -1 and len(parteFinal) < 7 ):
                        #Significa que es el final de un boundary
                        Resultado = Resultado + parteFinal
                        #print " la parte que se pone al final %s "  % parteFinal
                        #print "-->                  FINAL BOUNDARY %d " % len(parteFinal)
                        #comprobacion tonta
                        #esfinalboundary = parteFinal[0:2]
                        #if (esfinalboundary.count(b'--')==1):
                        #       print "                 FINAL BOUNDARY "
                elif (i2 == -1 and len(parteFinal) >= 7):
                        print "|| || || || || || posible error, parte final: longitud %d \n %s " % (len(parteFinal),parteFinal[-40:])
                #else:
                        #print "-->indicador boundary: %s" % (parteFinal[i2:i2+lenbound+2])
                                
                        
                
                
        
    return Resultado
    
                                
def analysisFicheroEML(contenido):
        """
        #buscar el primer Content-Type
                #si es multipart
                        #cortar hasta el final y extraer boundary="", pasar a la funcion corte  y valor boundary
                        #funcion->extraer boundary
                        #funcion->tratar boundary
        #si no es multipart
                        #funcion->tratar Content
        """

        global fichero_actual
        
	print "\n\n- - - - - INICIO: - - - - - - -  - - - -  - - - - " 
        #buscar el primer content-Type
        i1 = contenido.find(b'Content-Type: ')
        if (i1 == -1):
                return 'error\r\n'

        #cortar
        parte0 = contenido[0:i1]
        auxiliar = contenido[i1:]
        print "- - - - - contenido: %s " % contenido[i1:i1+100]

        
        #buscar tipo
        i2pc = auxiliar.find(b';')
        #i2rns = auxiliar.find("\r\n")

        #i2rnb = auxiliar.find(b'\x0D\x0A')

        #SALTO DE LINEA
        #windows version
        i2rn = auxiliar.find("\x0D\x0A")
        #linux version
        i2n = auxiliar.find("\x0A")
        
        #DOLE SALTO DE LINEA (FINAL DESCRIPCION DEL BLOQUE)
        #windows version
        i2rnrn = auxiliar.find("\x0D\x0A\x0D\x0A")
        #linux version
        i2nn = auxiliar.find("\x0A\x0A")
        
        
        if(i2pc != -1 and (i2pc < i2rn or i2pc < i2n)):
                i2=i2pc 
        else:
                i2 = max(i2rn,i2n)
       
        parte2 = auxiliar[0:i2+1]
	parteAttachment = auxiliar[0:max(i2rnrn,i2nn)+1]
	
	
	print "- - - - - final de linea: %s" % parte2
	
	print "- - - - - parte attachment: %s" % parteAttachment
	
        #numero ocurencias de palabra multipart
        esmultipart = parte2.count(b'multipart')
        
        #numero de ocurencias de palabra attachment
        esattachment = parteAttachment.count(b'Content-Disposition: attachment;')
        
        #tipo de content (content type)
        estext = parte2.count(b'text')
        esrichtext = parte2.count(b'richtext')
        esword = parte2.count(b'msword')
        esword2 = parte2.count(b'MSWORD')
        esimage = parte2.count(b'image')
        esimage2 = parte2.count(b'Image')
        esapplication = parte2.count(b'application')
        esdispositionnotific = parte2.count(b'disposition-notification')
        esdeliverystatus = parte2.count(b'delivery-status') + parte2.count(b'Delivery-status')
        esrfc822 = parte2.count(b'rfc822')
        esvideo = parte2.count(b'video')
        esaudio = parte2.count(b'audio')
        esstream = parte2.count(b'octet-stream')

        if (esmultipart == 1):
		print "- - - - - es multipart "
                #extraer boundary
                ib1 = auxiliar.find(b'boundary="')
                ib1 = ib1 + 10
                boundary = auxiliar[ib1:]
                ib2 = boundary.find(b'"')
                boundary = boundary[0:ib2]
                #anadir boundar=" al resultado
                parte2b = auxiliar[i2+1:ib1 + ib2]
                parte2 = parte2 + parte2b 
                #print "boundary= %s i1:%d i2:%d" % (boundary,ib1,ib2)

                #cortar parte boundary
                parteBoundary = auxiliar[ib1 + ib2:]
                resultado = auxiliar[0:ib1 + ib2 ]
                #print "parte auxiliar cabecera de boundary %s " % resultado

                #pasar a funcion tratamiento boundaries
                resultado =  resultado + decodificacionBoundarySMTP(parteBoundary,boundary)
        elif (esattachment == 1):
                print "- - - - - es adjunto "
                resultado = decodificarAdjunto(auxiliar)
                #print "- - - - %s" % resultado
        elif (estext == 1):
		print "- - - - - es texto "
                resultado = decodificarContent(auxiliar)
		#print "%s" % resultado
        elif (esrichtext == 1):
		print "- - - - - es rich text "
                resultado = decodificarContent(auxiliar)
		#print "%s" % resultado
        elif (esimage2==1 or esaudio == 1 or esvideo == 1 or esdispositionnotific == 1 or esrfc822 == 1 or esdeliverystatus == 1 or esimage == 1 or esapplication == 1 or esword == 1 or esword2 == 1):
		print "- - - - - es adjunto "
                resultado = decodificarAdjunto(auxiliar)
		#print "- - - - %s" % resultado
        else:
                print "- - - - - error content-type no identificado: %s  en  %s" % (parte2,fichero_actual)
                #resultado = b'error content-type no identificado\r\n'
                resultado = decodificarAdjunto(auxiliar)
		#print "%s" % resultado
	print "- - - - - ACABADO\n"
	if (isinstance(resultado, str)):
		return  parte0 +  resultado
	else:
		return contenido
        
def mkdirRecursivo(directorio):
        aux = []
        while (not os.path.exists(directorio)):
                #print "el directorio %s no existe" % directorio
                aux.append(directorio)
                directorio = os.path.dirname(directorio)
                #print "directorios a crear: %d " % len(aux)

        
        aux.reverse()
        
        for eldir in aux:
                try:
                        os.mkdir(eldir)
                except Exception, e:
                        print "error creando directorio %s error %s " % (eldir,e)
                        



def decodificacionFicheroEML(fich):
    global directorio_actual
    global fichero_actual
    global fileresultado
    global fileParentResultado
    global contador
    global target
    global output
    global dirdestino
    global dirdestino_root
    global dirorigen
    global borrar_antiguo


    #fich_printable = fich.encode('8859')
    fich_printable = fich.encode('utf-8')    
    print "fichero encoded version:"
    print fich_printable
    print "fichero unicode version"
    print fich
    #fich = fich_printable
    (shortname, extension) = os.path.splitext(fich)
    #print "/////////////////////////   shortname %s extension %s /////////////////" % (shortname, extension)

    
    #and shortname.count('_DECODIFICADO_')==0 
    #if (extension == '.eml' ):
    if (os.path.isfile(fich) and extension == '' ):
       #print "****************************************************"
       #print "*         EN el fichero %s " % fich
       #print "****************************************************"
                
        try:

            
            
            
            f = open(fich,"rb")
            print "*****************+ fichero %s opened!!!***********************" % fich
            bb = f.read()
            f.close()

            contador = 0
            fichero_actual = fich


	    #insertar en la bd
            
            #llamar a analysisFicheroEML() con string? o con fichero??
            #print " directorio origen  %s " % (os.path.dirname(os.path.abspath(fich)))
            filename = os.path.basename(fich)
            fichero_actual = filename
            dirdestino = os.path.dirname(os.path.abspath(fich))
            
            
            if target.endswith(os.sep):
              target = target[:-1]
          
            if output.endswith(os.sep):
              output = output[:-1]
              
              
            #print " dirdestino : %s , target: %s, output: %s" % (dirdestino,target,output)
            dirdestino = dirdestino.replace(target,output,1)
            #print " dirdestino_replaced : %s , target: %s, output: %s" % (dirdestino,target,output)
            
            try:
                    if (not os.path.exists(dirdestino)):
                            #print "llamando a mkdir para %s " % dirdestino
                            mkdirRecursivo(dirdestino)
                           
            except OSError, e:
                    # Ignore directory exists error
                    if e.errno != errno.EEXIST:
                            raise

            
            fileresultado = os.path.join(dirdestino,filename)
            directorio_actual = dirdestino
            (shortname, extension) = os.path.splitext(fich)
            if (extension == ''):
              fileresultado = os.path.join(dirdestino,"%s.eml" % filename)


            try:
		    
		    rellenarCorreoBD(fileresultado)
		    fileParentResultado = fileresultado
                    Resultado = analysisFicheroEML(bb)
                    #print " escribiendo en : %s" % fileresultado
                    ffinal = open(fileresultado,'wb') 
                    ffinal.write(Resultado)
                    ffinal.close()
            except Exception, e:

                    #copiamos el fichero tal cual si no se ha podido decodificar
		    print "***********************************************"
		    print "*         ERROR                               *"
		    print "***********************************************"
		    print "Unexpected error:", sys.exc_info()[0],
		    print "Exception: ",e
		    #print " escribiendo en : %s" % fileresultado
                    ffinal = open(fileresultado,'wb') 
                    ffinal.write(bb)
                    ffinal.close()

		    rellenarCorreoBD(fileresultado)
                    
                    
                    try:
                        #guardar en la lista ficheros que han dado error de decodificacion
                        listaFicheros = os.path.join(dirdestino_root,"lista_errores.txt")
                        flista = open(listaFicheros,'a') 
                        flista.write(fich+ "ha dado error se ha escrito sin decodificar \r\n")
                        flista.close()
                    except:
                        #do nothing
                        a = 1
            """     
            try:
                #guardar en un fichero txt fich y fileresultado
                #primera linea fich, segunda fileresultado , tercera linea#
                listaFicheros = os.path.join(dirdestino,"lista.txt")
                flista = open(listaFicheros,'a') 
                flista.write(fich+ "\r\n")
                flista.write(fileresultado + "\r\n")
                flista.write("#\r\n")
                flista.close()
            except:
                #do nothing
                a = 1
            """
        except Exception, e:
                print "****************************************************"
                print "*         EN el fichero %s " % fich
                print "****************************************************"
                print "ERROR %s \nTRANTANDO FICHERO %s" % (e,fich)
                
                
                try:
                    #guardar en la lista ficheros que han dado error de decodificacion
                    listaFicheros = os.path.join(dirdestino_root,"lista_errores.txt")
                    flista = open(listaFicheros,'a') 
                    flista.write(fich+ "ha dado ERROR no se ha podido escribir\r\n")
                    flista.close()

		    #bd guardar
		    
                except:
                    #do nothing
                    a = 1
                        
                #exit();
                #print ""
                #print ""
            
        #-----------------------------------------BORRADO DE LOS ORIGINALES--------------------------
        
        try:
          if ( borrar_antiguo ):
            os.remove(fich)
          
        except Exception, e:
                print "****************************************************"
                print "*         EN borrando fichero %s " % fich
                print "****************************************************"
                print "ERROR %s \bBORRANDO FICHERO %s" % (e,fich)

        

#-----------------------------------------------------module--main-----------------------------------------------------        
def moduleMain (targetin, outputin, overwrite,dbname):

  global directorio_actual
  global fichero_actual
  global contador
  global target
  global output
  global dirdestino
  global dirdestino_root
  global dirorigen
  global borrar_antiguo

  global databasename
  
  output = outputin
  target = targetin
  try:
          os.mkdir(output)
  except OSError, e:
          # Ignore directory exists error
          if e.errno != errno.EEXIST:
                  raise


  
 

  borrar_antiguo = overwrite

  directorio_actual = os.path.dirname(target)

  dirdestino = os.path.dirname(output)
  dirdestino_root = dirdestino
  #anadir / al final o separador de sistema?
  dirorigen = directorio_actual



  #dbname
  databasename = os.path.abspath(dirdestino) + '/' + dbname
  if (not databasename.endswith('.db')):
	databasename = databasename + '.db'
  try:
    db = Database(databasename)
    db.close()
  except Exception, e:
    print "[moduleMain]1 create database %s " % e
    
 
  try:
    db = Database(databasename)
    db.initDatabase()
    db.close()
  except Exception, e:
    print "[moduleMain]2 initdatabase %s " % e
    

  pathwalker = DirWalker()
  pathwalker.walk(target,decodificacionFicheroEML)


 

#-----------------------------------------------------script--main-----------------------------------------------------
if __name__ == "__main__":
  output = 'output'
  target = os.curdir
  if len(sys.argv) < 3:
      #target = os.curdir
      sys.stderr.write('Usage: EMLDecoderv2.0.py <directorio_origen> <directorio_destino> ')
      sys.exit(1)
  else:
      target = sys.argv[1]
      output = sys.argv[2]


  try:
          os.mkdir(output)
  except OSError, e:
          # Ignore directory exists error
          if e.errno != errno.EEXIST:
                  raise

  borrar_antiguo = False
  
  directorio_actual = os.path.dirname(target)

  dirdestino = os.path.dirname(output)
  dirdestino_root = dirdestino
  #anadir / al final o separador de sistema?
  dirorigen = directorio_actual


  pathwalker = DirWalker()
  pathwalker.walk(target,decodificacionFicheroEML)


  #winsound.PlaySound("SystemQuestion", winsound.SND_ALIAS)
  #winsound.PlaySound("SystemHand", winsound.SND_ALIAS)
  #winsound.PlaySound("SystemExit", winsound.SND_ALIAS)
  #winsound.PlaySound("SystemExclamation", winsound.SND_ALIAS)









        
